﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;



public class Modebus
{
    public static byte[] X8_X7_X6_X4_X2_1_Table = new byte[256];
    // x8 + x7 + x6 + x4 + x2 + 1
    const byte poly = 0xd5;

    public static byte Crc_X8_X7_X6_X4_X2_1(byte[] bytes)
    {
        Byte crc = 0xD5;
        for (int i = 0; i < bytes.Length; i++)
        {
            crc = X8_X7_X6_X4_X2_1_Table[crc ^ bytes[i]];
        }
        return crc;
    }
    public static void Crc8Value()
    {
        Byte[] bytes = new Byte[256];
        for (int i = 0; i < 256; ++i)
        {
            int temp = i;
            for (int j = 0; j < 8; ++j)
            {
                if ((temp & 0x80) != 0)
                {
                    temp = (temp << 1) ^ poly;
                }
                else
                {
                    temp <<= 1;
                }
            }
            bytes[i] = (byte)temp;
        }
    }

    static Byte[] auchCRCHi = new Byte[]
    {
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
            0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
            0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
            0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
            0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
            0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
            0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
            0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
            0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
            0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
            0x40
    };
    static Byte[] auchCRCLo = new Byte[]
    {
            0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
            0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
            0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
            0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
            0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
            0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
            0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
            0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
            0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
            0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
            0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
            0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
            0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
            0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
            0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
            0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
            0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
            0x40
    };
    static byte[] CRC8Table = new byte[]
    {
            0x00,0x07,0x0E,0x09,0x1C,0x1B,0x12,0x15,0x38,0x3F,0x36,0x31,0x24,0x23,0x2A,0x2D,
            0x70,0x77,0x7E,0x79,0x6C,0x6B,0x62,0x65,0x48,0x4F,0x46,0x41,0x54,0x53,0x5A,0x5D,
            0xE0,0xE7,0xEE,0xE9,0xFC,0xFB,0xF2,0xF5,0xD8,0xDF,0xD6,0xD1,0xC4,0xC3,0xCA,0xCD,
            0x90,0x97,0x9E,0x99,0x8C,0x8B,0x82,0x85,0xA8,0xAF,0xA6,0xA1,0xB4,0xB3,0xBA,0xBD,
            0xC7,0xC0,0xC9,0xCE,0xDB,0xDC,0xD5,0xD2,0xFF,0xF8,0xF1,0xF6,0xE3,0xE4,0xED,0xEA,
            0xB7,0xB0,0xB9,0xBE,0xAB,0xAC,0xA5,0xA2,0x8F,0x88,0x81,0x86,0x93,0x94,0x9D,0x9A,
            0x27,0x20,0x29,0x2E,0x3B,0x3C,0x35,0x32,0x1F,0x18,0x11,0x16,0x03,0x04,0x0D,0x0A,
            0x57,0x50,0x59,0x5E,0x4B,0x4C,0x45,0x42,0x6F,0x68,0x61,0x66,0x73,0x74,0x7D,0x7A,
            0x89,0x8E,0x87,0x80,0x95,0x92,0x9B,0x9C,0xB1,0xB6,0xBF,0xB8,0xAD,0xAA,0xA3,0xA4,
            0xF9,0xFE,0xF7,0xF0,0xE5,0xE2,0xEB,0xEC,0xC1,0xC6,0xCF,0xC8,0xDD,0xDA,0xD3,0xD4,
            0x69,0x6E,0x67,0x60,0x75,0x72,0x7B,0x7C,0x51,0x56,0x5F,0x58,0x4D,0x4A,0x43,0x44,
            0x19,0x1E,0x17,0x10,0x05,0x02,0x0B,0x0C,0x21,0x26,0x2F,0x28,0x3D,0x3A,0x33,0x34,
            0x4E,0x49,0x40,0x47,0x52,0x55,0x5C,0x5B,0x76,0x71,0x78,0x7F,0x6A,0x6D,0x64,0x63,
            0x3E,0x39,0x30,0x37,0x22,0x25,0x2C,0x2B,0x06,0x01,0x08,0x0F,0x1A,0x1D,0x14,0x13,
            0xAE,0xA9,0xA0,0xA7,0xB2,0xB5,0xBC,0xBB,0x96,0x91,0x98,0x9F,0x8A,0x8D,0x84,0x83,
            0xDE,0xD9,0xD0,0xD7,0xC2,0xC5,0xCC,0xCB,0xE6,0xE1,0xE8,0xEF,0xFA,0xFD,0xF4,0xF3
    };

    public static byte CRC8Calculation(byte[] p, byte value)//CRC-8计算
    {
        byte crc8 = value;
        int Length = p.Length;
        for (; Length > 0; Length--)
        {
            crc8 = CRC8Table[crc8 ^ p[p.Length - Length]];
        }
        return (crc8);
    }


    public struct Crc16DataType
    {
        public Byte H;
        public Byte L;
    }
    public static Crc16DataType Uint16DataTypeToCrc16(UInt16 d)//U16数组转CRC16
    {
        Crc16DataType m;
        m.H = (Byte)(d >> 8);
        m.L = (Byte)(d >> 0);
        return m;
    }
    public static Crc16DataType BytesDataTypeToCrc16(Byte[] d)  //字节数组转CRC16
    {
        Crc16DataType m;
        m.H = d[0];
        m.L = d[1];
        return m;
    }
    public static UInt16 Crc16DataTypeToUInt16(Crc16DataType m)  //u16转crc-16
    {
        return (UInt16)((m.H << 8) | m.L);
    }
    public static UInt16[] Crc16DataTypeToUInt16(Crc16DataType[] m)
    {
        UInt16[] value = new UInt16[m.Length];
        for (int i = 0; i < m.Length; i++)
        {
            value[i] = (UInt16)((m[i].H << 8) | m[i].L);
        }
        return value;
    }
    public static Crc16DataType CRC16Calculation(Byte[] puchMsg)//初值默认0XFF,0XFF计算CRC16值 
    {
        Crc16DataType m;
        m.H = 0xFF;
        m.L = 0xFF;
        Int32 uIndex;
        for (int i = 0; i < puchMsg.Length; i++)
        {
            uIndex = m.H ^ puchMsg[i];
            m.H = (Byte)(m.L ^ auchCRCHi[uIndex]);
            m.L = auchCRCLo[uIndex];
        }
        return m;
    }
    public static Crc16DataType CRC16Calculation(Byte[] puchMsg, UInt32 length)//计算CRC16值 
    {
        Crc16DataType m;
        m.H = 0xFF;
        m.L = 0xFF;
        Int32 uIndex;
        for (int i = 0; i < length; i++)
        {
            uIndex = m.H ^ puchMsg[i];
            m.H = (Byte)(m.L ^ auchCRCHi[uIndex]);
            m.L = auchCRCLo[uIndex];
        }
        return m;
    }
    public static Byte[] CRC16CalculationAddValue(Byte[] puchMsg, int length)//初值默认0XFF,0XFF计算CRC16值，指定长度
    {
        Crc16DataType m;
        m.H = 0xFF;
        m.L = 0xFF;
        Byte[] data = new byte[length + 2];
        Int32 uIndex;
        for (int i = 0; i < length; i++)
        {
            uIndex = m.H ^ puchMsg[i];
            m.H = (Byte)(m.L ^ auchCRCHi[uIndex]);
            m.L = auchCRCLo[uIndex];
        }
        Buffer.BlockCopy(puchMsg, 0, data, 0, puchMsg.Length);
        data[data.Length - 2] = m.H;
        data[data.Length - 1] = m.L;
        return data;
    }
    public static Crc16DataType CRC16Calculation(Crc16DataType m, Byte[] puchMsg)//指定初值,计算CRC16值
    {
        Int32 uIndex;
        for (int i = 0; i < puchMsg.Length; i++)
        {
            uIndex = m.H ^ puchMsg[i];
            m.H = (Byte)(m.L ^ auchCRCHi[uIndex]);
            m.L = auchCRCLo[uIndex];
        }
        return m;
    }



    public static Boolean CheckCRC16(Byte[] puchMsg)//对接收的整包数据进行校验,数据包含2个CRC值
    {
        if (puchMsg == null || puchMsg.Length < 2) return false;
        Crc16DataType[] m = new Crc16DataType[2];
        m[0] = CRC16Calculation(puchMsg.Skip(0).Take(puchMsg.Length - 2).ToArray());
        m[1].H = puchMsg[puchMsg.Length - 2];
        m[1].L = puchMsg[puchMsg.Length - 1];
        if (m[0].H == m[1].H && m[0].L == m[1].L) return true;
        else return false;
    }
    public static Byte[] AddCrc16Value(Byte[] puchMsg)//计算CRC16值增加在后面并返回计算后的整个数据包
    {
        Byte[] bytes = new Byte[puchMsg.Length + 2];
        Array.Copy(puchMsg, 0, bytes, 0, puchMsg.Length);
        Crc16DataType m = CRC16Calculation(puchMsg);
        bytes[bytes.Length - 2] = (Byte)m.H;
        bytes[bytes.Length - 1] = (Byte)m.L;
        return bytes;
    }

    public static Byte[] Crc16ChekArray(Byte[] data1, Byte[] data2)//计算2个数组
    {
        Byte[] data = new byte[data1.Length + data2.Length];
        Array.Copy(data1, 0, data, 0, data1.Length);
        Array.Copy(data2, 0, data, data1.Length, data2.Length);
        return AddCrc16Value(data); 
    }
    public static Byte[] Crc16ChekArray(Byte[] data1, Byte[] data2, Byte[] data3)//计算3个数组
    {
        Byte[] data = new byte[data1.Length + data2.Length +data3.Length];
        Array.Copy(data1, 0, data, 0, data1.Length);
        Array.Copy(data2, 0, data, data1.Length, data2.Length);
        Array.Copy(data3, 0, data, data1.Length+ data2.Length, data3.Length);
        return AddCrc16Value(data); 
    }


    public static Crc16DataType Hex16ToModBusDataType(UInt16 d)
    {
        Crc16DataType m;
        m.H = (byte)(d >> 8);
        m.L = (byte)(d >> 0);
        return m;
    }

    public static Byte[] ContinuousReading(Byte hardAddress, UInt16 regAddress, UInt16 regQuantity)  //连续读0X03指令
    {
        Byte[] data = new Byte[6];
        data[0] = hardAddress;
        data[1] = 0X03;
        data[2] = (Byte)(regAddress >> 8);
        data[3] = (Byte)(regAddress >> 0);
        data[4] = (Byte)(regQuantity >> 8);
        data[5] = (Byte)(regQuantity >> 0);
        Crc16DataType m = CRC16Calculation(data);
        Byte[] resultData = new Byte[data.Length + 2];
        Buffer.BlockCopy(data, 0, resultData, 0, data.Length);

        resultData[data.Length - 2] = m.H;
        resultData[data.Length - 1] = m.L;

        return resultData;
    }

    public static Byte[] ContinuousWrite(Byte hardAddress, UInt16 regAddress, UInt16 regQuantity, Byte[] writeData)  //连续读0X06写单个
    {
        Byte[] data = new Byte[6 + writeData.Length];
        data[0] = hardAddress;
        data[1] = 0X10;
        data[2] = (Byte)(regAddress >> 8);
        data[3] = (Byte)(regAddress >> 0);
        data[4] = (Byte)(regQuantity >> 8);
        data[5] = (Byte)(regQuantity >> 0);
        for (UInt16 i = 0; i < writeData.Length; i++)
        {
            data[6 + i] = writeData[i];
        }
        Crc16DataType m = CRC16Calculation(data);
        Byte[] resultData = new Byte[data.Length + 2];
        Buffer.BlockCopy(data, 0, resultData, 0, data.Length);

        resultData[resultData.Length - 2] = m.H;
        resultData[resultData.Length - 1] = m.L;

        return resultData;
    }
    public static Byte[] WriteSingle(Byte hardAddress, UInt16 regAddress, UInt16 writeData)  //连续读0X06写单个
    {
        Byte[] data = new Byte[6];
        data[0] = hardAddress;
        data[1] = 0X06; 
        data[2] = (Byte)(regAddress >> 8);
        data[3] = (Byte)(regAddress >> 0);
        data[4] = (Byte)(writeData >> 8);
        data[5] = (Byte)(writeData >> 0);

        Crc16DataType m = CRC16Calculation(data);
        Byte[] resultData = new Byte[data.Length + 2];

        Buffer.BlockCopy(data, 0, resultData, 0, data.Length);
        resultData[resultData.Length - 2] = m.H;
        resultData[resultData.Length - 1] = m.L;

        return resultData;
    }
    static public Byte[] DataPack(Byte[] buffer)
    {
        Byte[] data = new byte[buffer.Length + 2];
        Buffer.BlockCopy(buffer, 0, data, 0, buffer.Length);
        Modebus.Crc16DataType m = Modebus.CRC16Calculation(buffer);
        data[data.Length - 2] = m.H;
        data[data.Length - 1] = m.L;  //当前包CRC
        return data;
    }
    static public Byte[] DataPack(Byte[] data1, byte[] data2)
    {

        Byte[] data3 = new byte[data1.Length + data2.Length];
        Array.Copy(data1, 0, data3, 0, data1.Length);
        Array.Copy(data2, 0, data3, data1.Length, data2.Length);

        Modebus.Crc16DataType m = Modebus.CRC16Calculation(data3);

        Byte[] data4 = new byte[data3.Length + 2];
        Buffer.BlockCopy(data3, 0, data4, 0, data3.Length);

        data4[data4.Length - 2] = m.H;
        data4[data4.Length - 1] = m.L;  //当前包CRC
        return data4;
    }


    static public Byte[] DataIntercept(Byte[] datas, Int32 startPoint, Int32 endPoint)  //数据截取
    {

        return datas.Skip(startPoint).Take(endPoint).ToArray();

    }






    ///////////////**************************************************************

    public struct RecvDataType
    {
        public Byte HardAddress;
        public Byte Cmd;
        public UInt16 DataAddress;
        public UInt16[] Data;
    }

    public static RecvDataType ReadRecvData(Byte[] ReData)  //读取数据
    {
        RecvDataType r = new RecvDataType();
        try
        {
            r.Data = new UInt16[(ReData.Length - 6) / 2];
            if (CheckCRC16(ReData) == true && ReData.Length > 7 && ReData.Length % 2 == 0)
            {
                r.HardAddress = ReData[0];
                r.Cmd = ReData[1];
                r.DataAddress = (UInt16)((ReData[2] << 8) + ReData[3]);
                for (UInt16 i = 0; i < (ReData.Length - 6) / 2; i++)
                {
                    r.Data[i] = (UInt16)((ReData[4 + i * 2] << 8) + ReData[5 + i * 2]);
                }
            }
            else
            {
                r.Cmd = 0XFF;
            }
        }
        catch
        {

        }
        return r;
    }
}
